/**
 * 日志文件路径规格配置
 * 所有日志文件都从 dump_info 文件夹开始解析
 * 路径兼容Windows和Linux系统
 */

// 路径标准化函数，确保跨平台兼容性
function normalizePath(path: string): string {
  // 将Windows反斜杠转换为正斜杠，确保跨平台兼容
  return path.replace(/\\/g, '/')
}

export const LOG_PATHS = {
  // 根目录
  ROOT: normalizePath('dump_info'),
  
  // 版本信息相关
  VERSION: {
    // 组件版本日志位置
    COMPONENT_VERSION: normalizePath('dump_info/RTOSDump/versioninfo/package_info'),
    // BMC版本日志位置
    BMC_VERSION: normalizePath('dump_info/RTOSDump/versioninfo/app_revision.txt')
  },
  
  // 日志转储相关
  LOG_DUMP: {
    // 操作日志位置（有转储压缩包）
    OPERATION: normalizePath('dump_info/LogDump/operation.log'),
    // 运行日志位置（有转储压缩包）
    APP: normalizePath('dump_info/LogDump/app.log'),
    // 框架日志位置（有转储压缩包）
    FRAMEWORK: normalizePath('dump_info/LogDump/framework.log')
  },
  
  // 应用程序转储相关
  APP_DUMP: {
    // 告警日志位置
    EVENT: normalizePath('dump_info/AppDump/event/eo_sel.csv'),
    // 组件资源树日志位置（xx为组件名称）
    COMPONENT_RESOURCE: normalizePath('dump_info/AppDump/{component}/mdb_info.log')
  },
  
  // 实时操作系统转储相关
  RTOS_DUMP: {
    ROOT: normalizePath('dump_info/RTOSDump'),
    VERSION_INFO: normalizePath('dump_info/RTOSDump/versioninfo')
  }
} as const

/**
 * 日志文件类型枚举
 */
export enum LogFileType {
  COMPONENT_VERSION = 'component_version',
  BMC_VERSION = 'bmc_version',
  OPERATION_LOG = 'operation_log',
  APP_LOG = 'app_log',
  FRAMEWORK_LOG = 'framework_log',
  EVENT_LOG = 'event_log',
  COMPONENT_RESOURCE = 'component_resource'
}

/**
 * 日志文件类型映射
 */
export const LOG_FILE_TYPE_MAP = {
  [LogFileType.COMPONENT_VERSION]: LOG_PATHS.VERSION.COMPONENT_VERSION,
  [LogFileType.BMC_VERSION]: LOG_PATHS.VERSION.BMC_VERSION,
  [LogFileType.OPERATION_LOG]: LOG_PATHS.LOG_DUMP.OPERATION,
  [LogFileType.APP_LOG]: LOG_PATHS.LOG_DUMP.APP,
  [LogFileType.FRAMEWORK_LOG]: LOG_PATHS.LOG_DUMP.FRAMEWORK,
  [LogFileType.EVENT_LOG]: LOG_PATHS.APP_DUMP.EVENT,
  [LogFileType.COMPONENT_RESOURCE]: LOG_PATHS.APP_DUMP.COMPONENT_RESOURCE
} as const

/**
 * 查找与 mdb_info.log 同级目录的 rpc_records.log 文件
 * @param extractedData 解压后的数据字符串
 * @returns rpc_records.log 文件内容，如果未找到则返回null
 */
export function findRPCRecordsFromMdbDirectory(extractedData: string): string | null {
  if (!extractedData) return null
  
  console.log('findRPCRecordsFromMdbDirectory - 开始查找与 mdb_info.log 同级目录的 rpc_records.log')
  console.log('findRPCRecordsFromMdbDirectory - 数据长度:', extractedData.length)
  
  const lines = extractedData.split('\n')
  const allFilePaths: string[] = []
  
  // 扫描所有文件路径
  for (let i = 0; i < lines.length; i++) {
    const line = lines[i]
    const trimmedLine = line.trim()
    const normalizedLine = normalizePath(trimmedLine)
    if (normalizedLine.startsWith('dump_info/') && normalizedLine.includes('.')) {
      allFilePaths.push(normalizedLine)
    }
  }
  
  console.log('findRPCRecordsFromMdbDirectory - 发现的所有文件路径数量:', allFilePaths.length)
  console.log('findRPCRecordsFromMdbDirectory - 前10个文件路径:', allFilePaths.slice(0, 10))
  
  // 查找所有 mdb_info.log 文件
  const mdbInfoPaths = allFilePaths.filter(path => path.endsWith('/mdb_info.log'))
  console.log('findRPCRecordsFromMdbDirectory - 找到的 mdb_info.log 文件:', mdbInfoPaths)
  
  if (mdbInfoPaths.length === 0) {
    console.log('findRPCRecordsFromMdbDirectory - 未找到任何 mdb_info.log 文件')
    return null
  }
  
  // 收集所有组件的 rpc_records.log 内容
  const allRpcContents: string[] = []
  let foundCount = 0
  
  // 对于每个 mdb_info.log，查找同级目录的 rpc_records.log
  for (const mdbPath of mdbInfoPaths) {
    // 获取目录路径（去掉 /mdb_info.log）
    const dirPath = mdbPath.substring(0, mdbPath.lastIndexOf('/mdb_info.log'))
    const rpcRecordsPath = dirPath + '/rpc_records.log'
    
    console.log('findRPCRecordsFromMdbDirectory - 检查路径:', rpcRecordsPath)
    
    // 检查是否存在对应的 rpc_records.log
    if (allFilePaths.includes(rpcRecordsPath)) {
      console.log('findRPCRecordsFromMdbDirectory - 找到 rpc_records.log:', rpcRecordsPath)
      
      // 提取文件内容
      const content = extractFileContent(extractedData, rpcRecordsPath)
      if (content) {
        foundCount++
        allRpcContents.push(content)
        console.log(`findRPCRecordsFromMdbDirectory - 成功提取第${foundCount}个文件内容，长度:`, content.length)
        console.log(`findRPCRecordsFromMdbDirectory - 第${foundCount}个文件内容预览:`, content.substring(0, 200))
      }
    } else {
      console.log('findRPCRecordsFromMdbDirectory - 该目录下未找到 rpc_records.log:', rpcRecordsPath)
    }
  }
  
  if (allRpcContents.length === 0) {
    console.log('findRPCRecordsFromMdbDirectory - 所有 mdb_info.log 同级目录都未找到 rpc_records.log')
    return null
  }
  
  // 合并所有文件内容
  const combinedContent = allRpcContents.join('\n')
  console.log(`findRPCRecordsFromMdbDirectory - 成功汇聚 ${foundCount} 个组件的 rpc_records.log 文件`)
  console.log('findRPCRecordsFromMdbDirectory - 汇聚后总内容长度:', combinedContent.length)
  console.log('findRPCRecordsFromMdbDirectory - 汇聚后内容预览:', combinedContent.substring(0, 300))
  
  return combinedContent
}

/**
 * 从解压数据中提取指定路径的文件内容
 * @param extractedData 解压后的数据
 * @param filePath 文件路径
 * @returns 文件内容或null
 */
export function extractFileContent(extractedData: string, filePath: string): string | null {
  if (!extractedData || !filePath) return null
  
  console.log('extractFileContent - 查找文件路径:', filePath)
  console.log('extractFileContent - 数据长度:', extractedData.length)
  
  const lines = extractedData.split('\n')
  let inTargetFile = false
  let fileContent: string[] = []
  let foundFile = false
  let foundFileLineNumber = -1

  // 标准化目标文件路径，确保跨平台兼容
  const normalizedTargetPath = normalizePath(filePath)
  console.log('extractFileContent - 标准化目标路径:', normalizedTargetPath)

  // 首先扫描所有文件路径，看看有哪些文件
  const allFilePaths: string[] = []
  for (let i = 0; i < lines.length; i++) {
    const line = lines[i]
    const trimmedLine = line.trim()
    const normalizedLine = normalizePath(trimmedLine)
    // 修复：支持无扩展名文件（如package_info），不强制要求包含'.'
    if (normalizedLine.startsWith('dump_info/') && 
        (normalizedLine.includes('.') || normalizedLine.includes('package_info') || normalizedLine.includes('version'))) {
      allFilePaths.push(normalizedLine)
    }
  }
  console.log('extractFileContent - 发现的所有文件路径:', allFilePaths.slice(0, 10)) // 只显示前10个
  
  // 检查目标文件是否在列表中
  const targetExists = allFilePaths.includes(normalizedTargetPath)
  console.log('extractFileContent - 目标文件是否存在:', targetExists)
  
  if (!targetExists) {
    console.log('extractFileContent - 目标文件不存在，返回null')
    return null
  }

  for (let i = 0; i < lines.length; i++) {
    const line = lines[i]
    const trimmedLine = line.trim()

    // 检查是否是目标文件路径行，使用精确匹配
    const normalizedLine = normalizePath(trimmedLine)
    if (normalizedLine === normalizedTargetPath) {
      console.log('extractFileContent - 找到目标文件:', trimmedLine, '在第', i+1, '行')
      inTargetFile = true
      foundFile = true
      foundFileLineNumber = i
      continue
    }

    // 如果在目标文件中，收集内容直到遇到下一个文件路径
    if (inTargetFile) {
      // 检查是否遇到下一个文件路径（以 dump_info/ 开头的新路径）
      const normalizedLine = normalizePath(trimmedLine)
      if (normalizedLine.startsWith('dump_info/') && 
          normalizedLine !== normalizedTargetPath &&
          (normalizedLine.includes('.') || normalizedLine.includes('package_info') || normalizedLine.includes('version'))) {
        console.log('extractFileContent - 遇到下一个文件，结束当前文件:', trimmedLine, '在第', i+1, '行')
        break
      }
      fileContent.push(line)
    }
  }

  console.log('extractFileContent - 文件是否找到:', foundFile)
  console.log('extractFileContent - 找到文件的行号:', foundFileLineNumber)
  console.log('extractFileContent - 收集到的行数:', fileContent.length)
  console.log('extractFileContent - 内容预览:', fileContent.slice(0, 3).join('\\n'))
  
  if (foundFile && fileContent.length === 0) {
    console.log('extractFileContent - 警告：找到文件但内容为空')
    return null
  }
  
  return fileContent.length > 0 ? fileContent.join('\n') : null
}

/**
 * 从运行日志内容中提取组件列表
 * @param runtimeLogContent 运行日志内容
 * @returns 组件名称数组
 */
export function extractComponentList(runtimeLogContent: string): string[] {
  if (!runtimeLogContent) return []

  const components = new Set<string>()
  const lines = runtimeLogContent.split('\n')
  let runtimeLogCount = 0

  for (const line of lines) {
    const trimmedLine = line.trim()
    
    // 只从运行日志格式中提取组件
    // 格式: 2025-07-18 11:05:21.750324 pcie_device ERROR: ...
    const runtimeMatch = trimmedLine.match(/^\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2}\.\d+\s+([a-zA-Z_][a-zA-Z0-9_]*)\s+[A-Z]+:/)
    if (runtimeMatch) {
      components.add(runtimeMatch[1])
      runtimeLogCount++
    }
  }

  console.log(`从运行日志中提取到 ${components.size} 个组件:`, Array.from(components))
  console.log(`共处理了 ${runtimeLogCount} 条运行日志行`)

  return Array.from(components).sort()
}

/**
 * 检查解压数据是否包含dump_info文件夹
 * @param extractedData 解压后的数据
 * @returns 是否包含dump_info
 */
export function hasDumpInfoFolder(extractedData: string): boolean {
  if (!extractedData) return false
  return extractedData.includes('dump_info/')
}

/**
 * 获取指定组件的资源树日志路径
 * @param componentName 组件名称
 * @returns 完整的文件路径
 */
export function getComponentResourcePath(componentName: string): string {
  return LOG_PATHS.APP_DUMP.COMPONENT_RESOURCE.replace('{component}', componentName)
}